package 炫彩基类

import (
	common "gitee.com/go_888/xcgui/xcgui/common"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
	"syscall"
	"unsafe"
)

var (
	kernel32               = syscall.NewLazyDLL("kernel32.dll")
	procGetCurrentThreadId = kernel32.NewProc("GetCurrentThreadId")
)

// 获取当前线程ID.
func getCurrentThreadId() uint32 {
	r, _, _ := procGetCurrentThreadId.Call()
	return uint32(r)
}

// ThreadId 是 UI 线程 ID. 会在炫彩初始化时赋值.
var ThreadId uint32

// IsUiThread 判断当前线程是否是 UI 线程.
// ff:
func IsUiThread() bool {
	return ThreadId == getCurrentThreadId()
}

// XInitXCGUI 炫彩_初始化. 在调用本函数之前请先调用 xc.LoadXCGUI().
//
// ff:初始化
// bD2D:是否启用D2D
func X初始化(是否启用D2D bool) bool {
	r, _, _ := xInitXCGUI.Call(common.X布尔值到uintptr(是否启用D2D))
	if r != 0 {
		ThreadId = getCurrentThreadId()
		return true
	}
	return false
}

// XRunXCGUI 炫彩_运行, 运行消息循环, 当炫彩窗口数量为0时退出.
// ff:运行
func X运行() {
	xRunXCGUI.Call()
}

// XExitXCGUI 炫彩_退出, 退出界面库释放资源.
// ff:退出
func X退出() {
	xExitXCGUI.Call()
}

// XC_DebugToFileInfo 炫彩_输出调试信息到文件, 打印调试信息到文件xcgui_debug.txt.
//
// ff:输出调试信息到文件
// pInfo:文本
func X输出调试信息到文件(文本 string) {
	xC_DebugToFileInfo.Call(W2A(文本))
}

// XC_SetActivateTopWindow 炫彩_激活窗口, 激活当前进程最上层窗口.
// ff:激活窗口
func X激活窗口() bool {
	r, _, _ := xC_SetActivateTopWindow.Call()
	return r != 0
}

// XC_GetDefaultFont 炫彩_取默认字体. 返回字体句柄.
// ff:取默认字体
func X取默认字体() int {
	r, _, _ := xC_GetDefaultFont.Call()
	return int(r)
}

// XC_MessageBox 炫彩_消息框. 返回值如下:
//   - xcc.MessageBox_Flag_Ok: 点击确定按钮退出.
//   - xcc.MessageBox_Flag_Cancel: 点击取消按钮退出.
//   - xcc.MessageBox_Flag_Other: 其他方式退出.
//
//
//
//
//
// ff:消息框
// pTitle:标题
// pText:内容
// nFlags:标识
// hWndParent:父窗口句柄
// XCStyle:XC样式
func X消息框(标题, 内容 string, 标识 xcc.X消息框, 父窗口句柄 uintptr, XC样式 xcc.X窗口样式) xcc.X消息框 {
	r, _, _ := xC_MessageBox.Call(common.X文本到uintptr(标题), common.X文本到uintptr(内容), uintptr(标识), 父窗口句柄, uintptr(XC样式))
	return xcc.X消息框(r)
}

// XMsg_Create 消息框_创建, 返回消息框窗口句柄.
//
//
//
//
//
// ff:消息框_创建
// pTitle:标题
// pText:内容文本
// nFlags:标识
// hWndParent:父窗口句柄
// XCStyle:XC样式
func X消息框_创建(标题, 内容文本 string, 标识 xcc.X消息框, 父窗口句柄 uintptr, XC样式 xcc.X窗口样式) int {
	r, _, _ := xMsg_Create.Call(common.X文本到uintptr(标题), common.X文本到uintptr(内容文本), uintptr(标识), 父窗口句柄, uintptr(XC样式))
	return int(r)
}

// XMsg_CreateEx 消息框_创建扩展, 返回消息框窗口句柄.
//
//
//
//
//
//
//
//
// ff:消息框_创建EX
// dwExStyle:窗口扩展样式
// dwStyle:窗口样式
// lpClassName:窗口类名
// pTitle:标题
// pText:内容文本
// nFlags:标识
// hWndParent:父窗口句柄
// XCStyle:XC样式
func X消息框_创建EX(窗口扩展样式 xcc.WS_EX_, 窗口样式 xcc.WS_, 窗口类名, 标题, 内容文本 string, 标识 xcc.X消息框, 父窗口句柄 uintptr, XC样式 xcc.X窗口样式) int {
	r, _, _ := xMsg_CreateEx.Call(uintptr(窗口扩展样式), uintptr(窗口样式), common.X文本到uintptr(窗口类名), common.X文本到uintptr(标题), common.X文本到uintptr(内容文本), uintptr(标识), 父窗口句柄, uintptr(XC样式))
	return int(r)
}

// 炫彩_发送窗口消息.
//
//
//
//
// ff:发送窗口消息
// hWindow:窗口句柄
// msg:消息值
// wParam:参数1
// lParam:参数2
func X发送窗口消息(窗口句柄 int, 消息值 uint32, 参数1, 参数2 uintptr) uintptr {
	r, _, _ := xC_SendMessage.Call(uintptr(窗口句柄), uintptr(消息值), 参数1, 参数2)
	return r
}

// 炫彩_投递窗口消息.
//
//
//
//
// ff:投递窗口消息
// hWindow:窗口句柄
// msg:消息值
// wParam:参数1
// lParam:参数2
func X投递窗口消息(窗口句柄 int, 消息值 uint32, 参数1, 参数2 uintptr) bool {
	r, _, _ := xC_PostMessage.Call(uintptr(窗口句柄), uintptr(消息值), 参数1, 参数2)
	return r != 0
}

// XC_CallUiThread 炫彩_调用界面线程, 调用UI线程, 设置回调函数, 在回调函数里操作UI.
//   - 回调函数尽量不要使用匿名函数, 使用匿名函数意味着你每次都在创建1个新的回调, 超过2000个时, 程序必将panic.
//   - 如果使用 XC_CallUiThreadEx, XC_CallUiThreader, XC_CallUT, CallUTAny 则没有此限制.
//
//
// ff:调用界面线程
// pCall:回调函数
// data:
// data:
func X调用界面线程(回调函数 func(data int) int, data int) int {
	r, _, _ := xC_CallUiThread.Call(syscall.NewCallback(回调函数), uintptr(data))
	return int(r)
}

// 炫彩_判断元素, 判断是否为元素句柄.
//
// ff:判断元素
// hEle:元素句柄
func X判断元素(元素句柄 int) bool {
	r, _, _ := xC_IsHELE.Call(uintptr(元素句柄))
	return r != 0
}

// 炫彩_判断窗口, 判断是否为窗口句柄.
//
// ff:判断窗口
// hWindow:窗口句柄
func X判断窗口(窗口句柄 int) bool {
	r, _, _ := xC_IsHWINDOW.Call(uintptr(窗口句柄))
	return r != 0
}

// 炫彩_判断形状对象, 判断是否为形状对象.
//
// ff:判断形状对象
// hShape:形状对象句柄
func X判断形状对象(形状对象句柄 int) bool {
	r, _, _ := xC_IsShape.Call(uintptr(形状对象句柄))
	return r != 0
}

// 炫彩_判断句柄包含类型, 判断句柄是否拥有该类型.
//
//
// ff:判断句柄包含类型
// hXCGUI:炫彩句柄
// nType:句柄类型
func X判断句柄包含类型(炫彩句柄 int, 句柄类型 xcc.X对象句柄类型) bool {
	r, _, _ := xC_IsHXCGUI.Call(uintptr(炫彩句柄), uintptr(句柄类型))
	return r != 0
}

// 炫彩_转换HWND到HWINDOW, 通过窗口HWND句柄获取HWINDOW句柄.
//
// ff:转换HWND到HWINDOW
// hWnd:窗口句柄HWND
func X转换HWND到HWINDOW(窗口句柄HWND uintptr) int {
	r, _, _ := xC_hWindowFromHWnd.Call(窗口句柄HWND)
	return int(r)
}

// 炫彩_置属性, 设置对象属性.
//
//
//
// ff:设置属性
// hXCGUI:对象句柄
// pName:属性名
// pValue:属性值
func X设置属性(对象句柄 int, 属性名 string, 属性值 string) bool {
	r, _, _ := xC_SetProperty.Call(uintptr(对象句柄), common.X文本到uintptr(属性名), common.X文本到uintptr(属性值))
	return r != 0
}

// 炫彩_取属性, 获取对象属性, 返回属性值.
//
//
// ff:取属性
// hXCGUI:对象句柄
// pName:属性名
func X取属性(对象句柄 int, 属性名 string) string {
	r, _, _ := xC_GetProperty.Call(uintptr(对象句柄), common.X文本到uintptr(属性名))
	return common.Uintptr到文本(r)
}

// 炫彩_注册窗口类名, 如果是在DLL中使用, 那么DLL卸载时需要注销窗口类名, 否则DLL卸载后, 类名所指向的窗口过程地址失效.
//
// ff:注册窗口类名
// pClassName:类名
func X注册窗口类名(类名 string) bool {
	r, _, _ := xC_RegisterWindowClassName.Call(common.X文本到uintptr(类名))
	return r != 0
}

// 炫彩_判断滚动视图扩展元素, 判断元素是否从滚动视图元素扩展的新元素, 包含滚动视图元素.
//
// ff:是否为滚动视图扩展元素
// hEle:元素句柄
func X是否为滚动视图扩展元素(元素句柄 int) bool {
	r, _, _ := xC_IsSViewExtend.Call(uintptr(元素句柄))
	return r != 0
}

// 炫彩_取对象类型, 获取句柄类型, 返回: XC_OBJECT_TYPE.
//
// ff:取对象类型
// hXCGUI:炫彩对象句柄
func X取对象类型(炫彩对象句柄 int) xcc.X对象句柄类型 {
	r, _, _ := xC_GetObjectType.Call(uintptr(炫彩对象句柄))
	return xcc.X对象句柄类型(r)
}

// 炫彩_取对象从ID, 通过ID获取对象句柄, 不包括窗口对象.
//
//
// ff:取对象并按ID
// hWindow:所属窗口句柄
// nID:ID值
func X取对象并按ID(所属窗口句柄 int, ID值 int32) int {
	r, _, _ := xC_GetObjectByID.Call(uintptr(所属窗口句柄), uintptr(ID值))
	return int(r)
}

// 炫彩_取对象从ID名称, 通过ID名称获取对象句柄.
//
//
// ff:取对象并按ID名称
// hWindow:所属窗口句柄
// pName:ID名称
func X取对象并按ID名称(所属窗口句柄 int, ID名称 string) int {
	r, _, _ := xC_GetObjectByIDName.Call(uintptr(所属窗口句柄), common.X文本到uintptr(ID名称))
	return int(r)
}

// 炫彩_取对象从UID, 通过UID获取对象句柄, 不包括窗口对象.
//
// ff:取对象并按UID
// nUID:UID值
func X取对象并按UID(UID值 int32) int {
	r, _, _ := xC_GetObjectByUID.Call(uintptr(UID值))
	return int(r)
}

// 炫彩_取对象从UID名称, 通过UID名称获取对象句柄.
//
// ff:取对象并按UID名称
// pName:UID名称
func X取对象并按UID名称(UID名称 string) int {
	r, _, _ := xC_GetObjectByUIDName.Call(common.X文本到uintptr(UID名称))
	return int(r)
}

// 炫彩_取对象从名称, 通过name获取对象句柄.
//
// ff:取对象并按名称
// pName:名称
func X取对象并按名称(名称 string) int {
	r, _, _ := xC_GetObjectByName.Call(common.X文本到uintptr(名称))
	return int(r)
}

// 炫彩_置绘制频率, 设置UI的最小重绘频率.
//
// ff:设置绘制频率
// nMilliseconds:最小间隔时间
func X设置绘制频率(最小间隔时间 int32) {
	xC_SetPaintFrequency.Call(uintptr(最小间隔时间))
}

// 炫彩_置文本渲染质量, 设置文本渲染质量.
//
// ff:设置文本渲染质量
// nType:
func X设置文本渲染质量(nType int32) {
	xC_SetTextRenderingHint.Call(uintptr(nType))
}

// 炫彩_启用GDI绘制文本, 将影响到以下函数: XDraw_TextOut, XDraw_TextOutEx, XDraw_TextOutA.
//
// ff:启用GDI绘制文本
// bEnable:是否启用
func X启用GDI绘制文本(是否启用 bool) {
	xC_EnableGdiDrawText.Call(common.X布尔值到uintptr(是否启用))
}

// 炫彩_判断矩形相交, 判断两个矩形是否相交及重叠.
//
//
// ff:判断矩形相交
// pRect1:矩形1
// pRect2:矩形2
func X判断矩形相交(矩形1 *X结构_矩形, 矩形2 *X结构_矩形) bool {
	r, _, _ := xC_RectInRect.Call(uintptr(unsafe.Pointer(矩形1)), uintptr(unsafe.Pointer(矩形2)))
	return r != 0
}

// 炫彩_组合矩形, 组合两个矩形区域.
//
//
//
// ff:组合矩形
// pDest:新的矩形区域
// pSrc1:源矩形1
// pSrc2:源矩形2
func X组合矩形(新的矩形区域 *X结构_矩形, 源矩形1 *X结构_矩形, 源矩形2 *X结构_矩形) {
	xC_CombineRect.Call(uintptr(unsafe.Pointer(新的矩形区域)), uintptr(unsafe.Pointer(源矩形1)), uintptr(unsafe.Pointer(源矩形2)))
}

// 炫彩_显示布局边界, 显示布局对象边界.
//
// ff:显示布局边界
// bShow:是否显示
func X显示布局边界(是否显示 bool) {
	xC_ShowLayoutFrame.Call(common.X布尔值到uintptr(是否显示))
}

// 炫彩_启用debug文件.
//
// ff:启用debug文件
// bEnable:是否启用
func X启用debug文件(是否启用 bool) {
	xC_EnableDebugFile.Call(common.X布尔值到uintptr(是否启用))
}

// 炫彩_启用资源监视器.
//
// ff:启用资源监视器
// bEnable:是否启用
func X启用资源监视器(是否启用 bool) {
	xC_EnableResMonitor.Call(common.X布尔值到uintptr(是否启用))
}

// 炫彩_置布局边界颜色.
//
// ff:设置布局边界颜色
// color:ABGR颜色值
func X设置布局边界颜色(ABGR颜色值 int) {
	xC_SetLayoutFrameColor.Call(uintptr(ABGR颜色值))
}

// 炫彩_启用错误弹窗, 启用错误弹出, 通过该接口可以设置遇到严重错误时不弹出消息提示框.
//
// ff:启用错误弹窗
// bEnabel:是否启用
func X启用错误弹窗(是否启用 bool) {
	xC_EnableErrorMessageBox.Call(common.X布尔值到uintptr(是否启用))
}

// 炫彩_启用自动退出程序, 启动或禁用自动退出程序, 当检测到所有用户创建的窗口都关闭时, 自动退出程序; 可调用 XC_PostQuitMessage() 手动退出程序.
//
// ff:启用自动退出程序
// bEnabel:是否启用
func X启用自动退出程序(是否启用 bool) {
	xC_EnableAutoExitApp.Call(common.X布尔值到uintptr(是否启用))
}

// 炫彩_取文本绘制大小.
//
//
//
//
// ff:取文本绘制大小
// pString:文本
// length:文本长度
// hFontX:字体
// pOutSize:返回大小
func X取文本绘制大小(文本 string, 文本长度 int32, 字体 int, 返回大小 *X结构_大小) {
	xC_GetTextSize.Call(common.X文本到uintptr(文本), uintptr(文本长度), uintptr(字体), uintptr(unsafe.Pointer(返回大小)))
}

// 炫彩_取文本显示大小.
//
//
//
//
// ff:取文本显示大小
// pString:文本
// length:文本长度
// hFontX:字体
// pOutSize:返回大小
func X取文本显示大小(文本 string, 文本长度 int32, 字体 int, 返回大小 *X结构_大小) {
	xC_GetTextShowSize.Call(common.X文本到uintptr(文本), uintptr(文本长度), uintptr(字体), uintptr(unsafe.Pointer(返回大小)))
}

// 炫彩_取文本显示大小扩展.
//
//
//
//
//
// ff:取文本显示大小EX
// pString:文本
// length:文本长度
// hFontX:字体
// nTextAlign:文本对齐方式
// pOutSize:
func X取文本显示大小EX(文本 string, 文本长度 int32, 字体 int, 文本对齐方式 xcc.X文本对齐, pOutSize *X结构_大小) {
	xC_GetTextShowSizeEx.Call(common.X文本到uintptr(文本), uintptr(文本长度), uintptr(字体), uintptr(文本对齐方式), uintptr(unsafe.Pointer(pOutSize)))
}

// XC_GetTextShowRect 炫彩_取文本显示矩形.
//
//
//
//
//
//
// ff:炫彩_取文本显示矩形
// pString:文本
// length:文本长度
// hFontX:字体
// nTextAlign:文本对齐
// width:宽
// pOutSize:返回大小
func X炫彩_取文本显示矩形(文本 string, 文本长度 int32, 字体 int, 文本对齐 xcc.X文本对齐, 宽 int32, 返回大小 *X结构_大小) {
	xC_GetTextShowRect.Call(common.X文本到uintptr(文本), uintptr(文本长度), uintptr(字体), uintptr(文本对齐), uintptr(宽), uintptr(unsafe.Pointer(返回大小)))
}

// 炫彩_置默认字体.
//
// ff:设置默认字体
// hFontX:炫彩字体句柄
func X设置默认字体(炫彩字体句柄 int) {
	xC_SetDefaultFont.Call(uintptr(炫彩字体句柄))
}

// 炫彩_添加搜索路径, 添加文件搜索路径, 默认路径为exe目录和程序当前运行目录.
//
// ff:添加搜索路径
// pPath:文件夹
func X添加搜索路径(文件夹 string) {
	xC_AddFileSearchPath.Call(common.X文本到uintptr(文件夹))
}

// 炫彩_初始化字体, 初始化LOGFONTW结构体.
//
//
//
//
//
//
//
// ff:初始化字体
// pFont:字体属性
// pName:字体名称
// size:字体大小
// bBold:是否加粗
// bItalic:是否斜体
// bUnderline:带下划线
// bStrikeOut:带删除线
func X初始化字体(字体属性 *X结构_字体属性, 字体名称 string, 字体大小 int32, 是否加粗 bool, 是否斜体 bool, 带下划线 bool, 带删除线 bool) {
	xC_InitFont.Call(uintptr(unsafe.Pointer(字体属性)), common.X文本到uintptr(字体名称), uintptr(字体大小), common.X布尔值到uintptr(是否加粗), common.X布尔值到uintptr(是否斜体), common.X布尔值到uintptr(带下划线), common.X布尔值到uintptr(带删除线))
}

// 炫彩_分配内存, 在UI库中申请内存, 返回: 内存首地址.
//
// ff:分配内存
// size:大小
func X分配内存(大小 int32) uintptr {
	r, _, _ := xC_Malloc.Call(uintptr(大小))
	return r
}

// 炫彩_释放内存, 在UI库中释放内存.
//
// ff:释放内存
// p:内存首地址
func X释放内存(内存首地址 uintptr) {
	xC_Free.Call(内存首地址)
}

// 炫彩_弹框, 弹出提示框.
//
//
// ff:弹框
// pTitle:提示框标题
// pText:提示内容
func X弹框(提示框标题, 提示内容 string) {
	xC_Alert.Call(common.X文本到uintptr(提示框标题), common.X文本到uintptr(提示内容))
}

// 对指定文件执行操作. 如果函数成功，则返回大于 32 的值。如果函数失败，则返回指示失败原因的错误值.
//
//
//
//
//
//
// ff:执行外部命令
// hwnd:父窗口句柄
// lpOperation:操作命令
// lpFile:文件或路径
// lpParameters:命令参数
// lpDirectory:默认目录
// nShowCmd:显示方式
func X执行外部命令(父窗口句柄 uintptr, 操作命令 string, 文件或路径 string, 命令参数 string, 默认目录 string, 显示方式 xcc.X窗口显示方式) uintptr {
	r, _, _ := xC_Sys_ShellExecute.Call(父窗口句柄, common.X文本到uintptr(操作命令), common.X文本到uintptr(文件或路径), common.X文本到uintptr(命令参数), common.X文本到uintptr(默认目录), uintptr(显示方式))
	return r
}

// 炫彩_载入动态库, 系统API LoadLibrary, 返回动态库模块句柄.
//
// ff:载入动态库
// lpFileName:文件名
func X载入动态库(文件名 string) uintptr {
	r, _, _ := xC_LoadLibrary.Call(common.X文本到uintptr(文件名))
	return r
}

// 炫彩_取动态库中函数地址, 系统API GetProcAddress, 返回函数地址.
//
//
// ff:取动态库中函数地址
// hModule:动态库模块句柄
// lpProcName:函数名
func X取动态库中函数地址(动态库模块句柄 uintptr, 函数名 string) uintptr {
	r, _, _ := xC_GetProcAddress.Call(动态库模块句柄, W2A(函数名))
	return r
}

// 炫彩_释放动态库, 系统API FreeLibrary.
//
// ff:释放动态库
// hModule:动态库模块句柄
func X释放动态库(动态库模块句柄 uintptr) bool {
	r, _, _ := xC_FreeLibrary.Call(动态库模块句柄)
	return r != 0
}

// 炫彩_加载DLL, 返回DLL模块句柄. 加载指定DLL, 并且调用DLL中函数LoadDll(), DLL中导出函数格式: int32 WINAPI LoadDll().
//
// ff:加载DLL
// pDllFileName:DLL文件名
func X加载DLL(DLL文件名 string) uintptr {
	r, _, _ := xC_LoadDll.Call(common.X文本到uintptr(DLL文件名))
	return r
}

// 炫彩_PostQuitMessage, 发送WM_QUIT消息退出消息循环.
//
// ff:发送退出消息
// nExitCode:退出码
func X发送退出消息(退出码 int32) {
	xC_PostQuitMessage.Call(uintptr(退出码))
}

// 炫彩_置D2D文本渲染模式.
//
// ff:设置D2D文本渲染模式
// mode:渲染模式
func X设置D2D文本渲染模式(渲染模式 xcc.D2D文本渲染模式) {
	xC_SetD2dTextRenderingMode.Call(uintptr(渲染模式))
}

// 炫彩_是否启用了D2D.
// ff:是否启用了D2D
func X是否启用了D2D() bool {
	r, _, _ := xC_IsEnableD2D.Call()
	return r != 0
}

// 炫彩_W2A.
//
// ff:W2A
// pValue:参数
func W2A(参数 string) uintptr {
	r, _, _ := xC_wtoa.Call(common.X文本到uintptr(参数))
	return r
}

// 炫彩_A2W.
//
// ff:A2W
// pValue:参数
func A2W(参数 uintptr) string {
	r, _, _ := xC_atow.Call(参数)
	return common.Uintptr到文本(r)
}

// 炫彩_UTF8到文本W.
//
// ff:UTF8到文本W
// pUtf8:参数
func UTF8到文本W(参数 uintptr) string {
	r, _, _ := xC_utf8tow.Call(参数)
	return common.Uintptr到文本(r)
}

// 炫彩_UTF8到文本W扩展.
//
//
// ff:UTF8到文本WEX
// pUtf8:utf8文本指针
// length:utf8文本长度
func UTF8到文本WEX(utf8文本指针 uintptr, utf8文本长度 int32) string {
	r, _, _ := xC_utf8towEx.Call(utf8文本指针, uintptr(utf8文本长度))
	return common.Uintptr到文本(r)
}

// 炫彩_UTF8到文本A.
//
// ff:UTF8到文本A
// pUtf8:utf8文本指针
func UTF8到文本A(utf8文本指针 uintptr) uintptr {
	r, _, _ := xC_utf8toa.Call(utf8文本指针)
	return r
}

// 炫彩_文本A到UTF8.
//
// ff:文本A到UTF8
// pValue:参数
func X文本A到UTF8(参数 uintptr) uintptr {
	r, _, _ := xC_atoutf8.Call(参数)
	return r
}

// 炫彩_文本W到UTF8.
//
// ff:文本W到UTF8
// pValue:文本
func X文本W到UTF8(文本 string) uintptr {
	r, _, _ := xC_wtoutf8.Call(common.X文本到uintptr(文本))
	return r
}

// 炫彩_文本W到UTF8扩展.
//
//
// ff:文本W到UTF8EX
// pValue:文本
// length:文本长度
func X文本W到UTF8EX(文本 string, 文本长度 int32) uintptr {
	r, _, _ := xC_wtoutf8Ex.Call(common.X文本到uintptr(文本), uintptr(文本长度))
	return r
}

// 炫彩_U2A, 返回写入接收缓冲区字节数量.
//
//
//
//
// ff:U2A
// pIn:待转换的Unicode文本
// inLen:pIn字符数量
// pOut:转换后缓冲区指针
// outLen:pOut缓冲区大小
func U2A(待转换的Unicode文本 string, pIn字符数量 int32, 转换后缓冲区指针 uintptr, pOut缓冲区大小 int32) int32 {
	r, _, _ := xC_UnicodeToAnsi.Call(common.X文本到uintptr(待转换的Unicode文本), uintptr(pIn字符数量), 转换后缓冲区指针, uintptr(pOut缓冲区大小))
	return int32(r)
}

// 炫彩_A2U, 返回写入接收缓冲区字符数量.
//
//
//
//
// ff:A2U
// pIn:指向待转换的Ansi文本指针
// inLen:pIn字符数量
// pOut:转换后缓冲区指针
// outLen:pOut缓冲区大小
func A2U(指向待转换的Ansi文本指针 uintptr, pIn字符数量 int32, 转换后缓冲区指针 *string, pOut缓冲区大小 int32) int32 {
	buf := make([]uint16, pOut缓冲区大小)
	r, _, _ := xC_AnsiToUnicode.Call(指向待转换的Ansi文本指针, uintptr(pIn字符数量), common.Uint16SliceDataPtr(&buf), uintptr(pOut缓冲区大小))
	*转换后缓冲区指针 = syscall.UTF16ToString(buf[0:])
	return int32(r)
}

// 炫彩_打印调试信息, 打印调试信息到文件xcgui_debug.txt.
//
//
// ff:调试输出
// level:级别
// pInfo:信息
func X调试输出(级别 int32, 信息 string) {
	xDebug_Print.Call(uintptr(级别), W2A(信息))
}

// 炫彩_显示边界.
//
// ff:显示边界
// bShow:是否显示
func X显示边界(是否显示 bool) {
	xC_ShowSvgFrame.Call(common.X布尔值到uintptr(是否显示))
}

// 炫彩_启用自动DPI. 当启用后, 创建窗口时自动检测DPI调整UI缩放, 处理DPI改变消息; 禁用后,当DPI改变,需要手动设置窗口DPI.
//
// ff:启用自动DPI
// bEnabel:是否启用
func X启用自动DPI(是否启用 bool) {
	xC_EnableAutoDPI.Call(common.X布尔值到uintptr(是否启用))
}

// 炫彩_启用DPI.
//
// 为go程序启用DPI的几种方式:
//  1. 调用此函数.
//  2. 使用程序清单文件, Windows文档里更推荐此方式.
//  3. 自行调用Windows DPI命令.
//
// 参考[MSDN](https://learn.microsoft.com/zh-cn/windows/win32/hidpi/setting-the-default-dpi-awareness-for-a-process)
//
// ff:启用DPI
// bEnabel:是否启用
func X启用DPI(是否启用 bool) bool {
	r, _, _ := xC_EnableDPI.Call(common.X布尔值到uintptr(是否启用))
	return r != 0
}

// 炫彩_置窗口图标. 全局窗口图标, 所有未设置图标的窗口, 都将使用此默认图标.
//
// ff:设置窗口图标
// hImage:图标句柄
func X设置窗口图标(图标句柄 int) {
	xC_SetWindowIcon.Call(uintptr(图标句柄))
}

// 炫彩_启用自动重绘UI. 当修改UI后将自动调用重绘函数更新UI.
//
// 例如改变了按钮标题后, 将自动调用 xc.XEle_Redraw 更新UI, 默认不启用, 手动和自动各有优势.
//
// ff:启用自动重绘UI
// bEnabel:是否启用
func X启用自动重绘UI(是否启用 bool) {
	xC_EnableAutoRedrawUI.Call(common.X布尔值到uintptr(是否启用))
}

// 炫彩_取句柄总数. 获取当前所使用的句柄总数量, 返回当前所使用的句柄总数量.
// ff:取句柄总数
func X取句柄总数() int32 {
	r, _, _ := xC_GetHandleCount.Call()
	return int32(r)
}

// 炫彩_置D2D文本抗锯齿模式.
//
// ff:
// mode:
func XC_SetD2dTextAntialiasMode(mode int32) {
	xC_SetD2dTextAntialiasMode.Call(uintptr(mode))
}

// 炫彩_是否初始化.
// ff:
func XC_IsInit() bool {
	r, _, _ := xC_IsInit.Call()
	return r != 0
}

/* // 炫彩_打印调试信息, 打印调试信息到文件xcgui_debug.txt.[无效]
//
// ff:
// pString:
func XDebug_OutputDebugStringW(pString string) int {
	r, _, _ := xDebug_OutputDebugStringW.Call(common.StrPtr(pString))
	return int(r)
}

// 炫彩_设置debug输出编码方式为utf8.[无效]
//
// ff:
// bUTF8:
func XDebug_Set_OutputDebugString_UTF8(bUTF8 bool) int {
	r, _, _ := xDebug_Set_OutputDebugString_UTF8.Call(common.BoolPtr(bUTF8))
	return int(r)
}

// 炫彩_整数到文本A.
//
// ff:
// nValue:
func XC_itoa(nValue int) int {
	r, _, _ := xC_itoa.Call(uintptr(nValue))
	return int(r)
}

// 炫彩_整数到文本W.
//
// ff:
// nValue:
func XC_itow(nValue int) int {
	r, _, _ := xC_itow.Call(uintptr(nValue))
	return int(r)
}

// 炫彩_浮点数到文本A.
//
// ff:
// fValue:
func XC_ftoa(fValue int) int {
	r, _, _ := xC_ftoa.Call(uintptr(fValue))
	return int(r)
}

// 炫彩_浮点数到文本W.
//
// ff:
// fValue:
func XC_ftow(fValue int) int {
	r, _, _ := xC_ftow.Call(uintptr(fValue))
	return int(r)
}
*/
